package testes;

import interfacesFerrovia.DefsGlobais.TipoAtributo;
import interfacesFerrovia.DefsGlobais.TipoElemento;

import java.util.HashMap;
import java.util.Map;

import controle.CControle;

import malha.CComposicao;
import malha.CMalha;


public class CMalhaTeste {

	/**
	 * Testa o metodo atualizarMalha
	 * @param malha Malha
	 */
	private void testeAtualizarMalha(CMalha malha) {
		malha.atualizarMalha();
	}
	
	/**
	 * Testa o metodo atualizarElemento
	 * @param malha Malha
	 * @param idElemento ID do elemento a ser atualizado
	 * @param atributos Mapa dos atributos
	 */
	private void testeAtualizarElemento(CMalha malha, String idElemento, Map<TipoAtributo, Object> atributos) {
		malha.atualizarElemento(idElemento, atributos);
	}
	
	/**
	 * Testa o metodo acelerarComposicao
	 * @param malha Malha
	 */
	private void testeAcelerarComposicao(CMalha malha) {
		malha.acelerarComposicao("composicao1", 1.0f, 4);
		malha.acelerarComposicao("composicao2", 1.8f, 1, 0.6f);
	}
	
	/**
	 * Testa o metodoFrearComposicao
	 * @param malha Malha
	 */
	private void testeFrearComposicao(CMalha malha) {
		malha.frearComposicao("composicao6", 0f, 6);
		malha.frearComposicao("composicao7", 0f, 6, 0.1f);
	}
	
	/**
	 * Testa o metodo adicionarComposicao
	 * @param malha
	 */
	private void testeAdicionarComposicao(CMalha malha) {
		int total = malha.getComposicoes().size();
		
		malha.adicionarComposicao("composicao1");
		malha.adicionarComposicao("composicao2");
		malha.adicionarComposicao("composicao3");
		malha.adicionarComposicao("composicao4");
		malha.adicionarComposicao("composicao5");
		malha.adicionarComposicao("composicao6");
		malha.adicionarComposicao("composicao7");
		
		assert(total + 7 == malha.getComposicoes().size());
	}
	
	/**
	 * Testa o metodo removerComposicao
	 * @param malha
	 */
	private void testeRemoverComposicao(CMalha malha) {
		String idComp = "composicao1";
		int total = malha.getComposicoes().size();
		
		HashMap<String, CComposicao> mapaOld = new HashMap<String, CComposicao>(malha.getComposicoes());
		mapaOld.remove(idComp);
		
		malha.removerComposicao(idComp);
		
		assert(malha.getComposicoes().equals(mapaOld));
		assert(total - 1 == malha.getComposicoes().size());
		
	}
	
	/**
	 * Testa o metodo mudarChave
	 * @param malha Malha
	 */
	private void testeMudarChave(CMalha malha) {
		malha.mudarChave("chave4", "trecho5", "trecho6");
	}
	
	/**
	 * Testa o metodo adicionarChave
	 * Adiciona 3 chaves com ID chave1, chave2...
	 * 
	 * @param malha Malha
	 */
	private void testeAdicionarChave(CMalha malha) {
		int total = malha.getChaves().size();
		
		malha.adicionarChave("chave1");
		malha.adicionarChave("chave2");
		malha.adicionarChave("chave3");
		malha.adicionarChave("chave4");
		
		assert(total + 4 == malha.getChaves().size());
	}
	
	/**
	 * Testa o metodo adicionarTrecho
	 * Adiciona 6 trechos com ID trecho1, trecho2...
	 * 
	 * @param malha Malha
	 */
	private void testeAdicionarTrecho(CMalha malha) {
		int total = malha.getTrechos().size();
		
		malha.adicionarTrecho("trecho1");
		malha.adicionarTrecho("trecho2");
		malha.adicionarTrecho("trecho3");
		malha.adicionarTrecho("trecho4");
		malha.adicionarTrecho("trecho5");
		malha.adicionarTrecho("trecho6");
		
		assert(total + 6 == malha.getTrechos().size());
	}
	
	/**
	 * Testa o metodo encontrarChaveAssociada 
	 * @param malha Malha
	 */
	private void testeEncontrarChaveAssociada(CMalha malha) {
		assert(malha.encontrarChaveAssociada("chave1") == "chave1");
		assert(malha.encontrarChaveAssociada("chave2") == "chave2");
		assert(malha.encontrarChaveAssociada("chave3") == "chave3");
		assert(malha.encontrarChaveAssociada("chave4") == "chave4");
		
		assert(malha.encontrarChaveAssociada("trecho1") == "chave2");
		assert(malha.encontrarChaveAssociada("trecho2") == "chave1");
		assert(malha.encontrarChaveAssociada("trecho3") == null);
		assert(malha.encontrarChaveAssociada("trecho4") == null);
		assert(malha.encontrarChaveAssociada("trecho5") == "chave4");
		
		assert(malha.encontrarChaveAssociada("composicao1") == "chave1");
		assert(malha.encontrarChaveAssociada("composicao2") == "chave2");
		assert(malha.encontrarChaveAssociada("composicao3") == "chave1");
		assert(malha.encontrarChaveAssociada("composicao4") == "chave2");
		assert(malha.encontrarChaveAssociada("composicao5") == "chave4");
		assert(malha.encontrarChaveAssociada("composicao6") == "chave1");
		assert(malha.encontrarChaveAssociada("composicao7") == "chave4");
	}
	
	/**
	 * Testa o metodo adicionarComposicaoACaminho
	 * @param malha Malha
	 */
	private void testeAdicionarComposicaoACaminho(CMalha malha) {
		malha.adicionarComposicaoACaminho("chave1", "composicao6");
		malha.adicionarComposicaoACaminho("chave2", "composicao2");
		malha.adicionarComposicaoACaminho("chave4", "composicao7");
	}
	
	/**
	 * Testa o metodo removerComposicaoACaminho
	 * @param malha Malha
	 */
	private void testeRemoverComposicaoACaminho(CMalha malha) {
		malha.removerComposicaoACaminho("chave2", "composicao2");
	}
	
	/**
	 * Testa o metodo proximaComposicaoACaminho
	 * @param malha
	 */
	private void testeProximaComposicaoACaminho(CMalha malha) {
		assert(malha.proximaComposicaoACaminho("chave1") == "composicao6");
		assert(malha.proximaComposicaoACaminho("chave2") == "composicao2");
		assert(malha.proximaComposicaoACaminho("chave4") == "composicao7");
	}
	
	/**
	 * Testa o metodo getTrensACaminho 
	 * @param malha Malha
	 */
	private void testeGetTrensACaminho(CMalha malha) {
		HashMap<String, Integer> mapa = malha.getTrensACaminho("chave2");
		
		HashMap<String, Integer> teste = new HashMap<String, Integer>();
		teste.put("composicao2", mapa.get("composicao2"));
		
		assert(teste.equals(mapa));
	}
	
	
	/**
	 * Testa a classe CMalha
	 * @param args
	 */
	public static void main(String[] args) {
		
		CControle controle = CControle.getControle();
		controle.setInstanteAtual(2);
		
		CMalha malha = new CMalha();
		CMalhaTeste teste = new CMalhaTeste();
		
		teste.testeAdicionarChave(malha);
		teste.testeAdicionarComposicao(malha);
		teste.testeAdicionarTrecho(malha);
		
		
		
		/***** CHAVES *****/
		
		HashMap<TipoAtributo, Object> mapaChave1 = new HashMap<TipoAtributo, Object>();
		mapaChave1.put(TipoAtributo.ID, "chave1");
		mapaChave1.put(TipoAtributo.TIPO, TipoElemento.CHAVE);
		mapaChave1.put(TipoAtributo.DISTANCIA, 10.5f);
		mapaChave1.put(TipoAtributo.TRECHOS_A, new String[] {"trecho6"});
		mapaChave1.put(TipoAtributo.TRECHOS_B, new String[] {"trecho1", "trecho2"});
		mapaChave1.put(TipoAtributo.ID_TR_CH_A, "trecho6");
		mapaChave1.put(TipoAtributo.ID_TR_CH_B, "trecho1");
		mapaChave1.put(TipoAtributo.TEMPO_MUDANCA, 5);
		mapaChave1.put(TipoAtributo.EM_MUDANCA, false);
		mapaChave1.put(TipoAtributo.TEMPO_CONCLUSAO, 0);
		
		HashMap<TipoAtributo, Object> mapaChave2 = new HashMap<TipoAtributo, Object>();
		mapaChave2.put(TipoAtributo.ID, "chave2");
		mapaChave2.put(TipoAtributo.TIPO, TipoElemento.CHAVE);
		mapaChave2.put(TipoAtributo.DISTANCIA, 5.5f);
		mapaChave2.put(TipoAtributo.TRECHOS_A, new String[] {"trecho1", "trecho3"});
		mapaChave2.put(TipoAtributo.TRECHOS_B, new String[] {"trecho4"});
		mapaChave2.put(TipoAtributo.ID_TR_CH_A, "trecho1");
		mapaChave2.put(TipoAtributo.ID_TR_CH_B, "trecho4");
		mapaChave2.put(TipoAtributo.TEMPO_MUDANCA, 1);
		mapaChave2.put(TipoAtributo.EM_MUDANCA, false);
		mapaChave2.put(TipoAtributo.TEMPO_CONCLUSAO, 0);
		
		HashMap<TipoAtributo, Object> mapaChave3 = new HashMap<TipoAtributo, Object>();
		mapaChave3.put(TipoAtributo.ID, "chave3");
		mapaChave3.put(TipoAtributo.TIPO, TipoElemento.CHAVE);
		mapaChave3.put(TipoAtributo.DISTANCIA, 8.5f);
		mapaChave3.put(TipoAtributo.TRECHOS_A, new String[] {"trecho2"});
		mapaChave3.put(TipoAtributo.TRECHOS_B, new String[] {"trecho3", "trecho5"});
		mapaChave3.put(TipoAtributo.ID_TR_CH_A, "trecho2");
		mapaChave3.put(TipoAtributo.ID_TR_CH_B, "trecho5");
		mapaChave3.put(TipoAtributo.TEMPO_MUDANCA, 2);
		mapaChave3.put(TipoAtributo.EM_MUDANCA, true);
		mapaChave3.put(TipoAtributo.TEMPO_CONCLUSAO, 1);
		
		HashMap<TipoAtributo, Object> mapaChave4 = new HashMap<TipoAtributo, Object>();
		mapaChave4.put(TipoAtributo.ID, "chave4");
		mapaChave4.put(TipoAtributo.TIPO, TipoElemento.CHAVE);
		mapaChave4.put(TipoAtributo.DISTANCIA, 9f);
		mapaChave4.put(TipoAtributo.TRECHOS_A, new String[] {"trecho4", "trecho5"});
		mapaChave4.put(TipoAtributo.TRECHOS_B, new String[] {"trecho6"});
		mapaChave4.put(TipoAtributo.ID_TR_CH_A, "trecho4");
		mapaChave4.put(TipoAtributo.ID_TR_CH_B, "trecho6");
		mapaChave4.put(TipoAtributo.TEMPO_MUDANCA, 3);
		mapaChave4.put(TipoAtributo.EM_MUDANCA, false);
		mapaChave4.put(TipoAtributo.TEMPO_CONCLUSAO, 0);
		
		
		
		/***** TRECHOS *****/
		
		HashMap<TipoAtributo, Object> mapaTrecho1 = new HashMap<TipoAtributo, Object>();
		mapaTrecho1.put(TipoAtributo.ID, "trecho1");
		mapaTrecho1.put(TipoAtributo.TIPO, TipoElemento.TRECHO);
		mapaTrecho1.put(TipoAtributo.DISTANCIA, 55.4f);
		mapaTrecho1.put(TipoAtributo.ID_TR_CH_A, "chave1");
		mapaTrecho1.put(TipoAtributo.ID_TR_CH_B, "chave2");
		mapaTrecho1.put(TipoAtributo.N_COMPOSICOES, 1);
		
		malha.getTrechos().get("trecho1").adicionarComposicao(malha.getComposicoes().get("composicao2"), true);
		
		HashMap<TipoAtributo, Object> mapaTrecho2 = new HashMap<TipoAtributo, Object>();
		mapaTrecho2.put(TipoAtributo.ID, "trecho2");
		mapaTrecho2.put(TipoAtributo.TIPO, TipoElemento.TRECHO);
		mapaTrecho2.put(TipoAtributo.DISTANCIA, 62.3f);
		mapaTrecho2.put(TipoAtributo.ID_TR_CH_A, "chave1");
		mapaTrecho2.put(TipoAtributo.ID_TR_CH_B, "chave3");
		mapaTrecho2.put(TipoAtributo.N_COMPOSICOES, 1);
		
		malha.getTrechos().get("trecho2").adicionarComposicao(malha.getComposicoes().get("composicao6"), true);
		
		HashMap<TipoAtributo, Object> mapaTrecho3 = new HashMap<TipoAtributo, Object>();
		mapaTrecho3.put(TipoAtributo.ID, "trecho3");
		mapaTrecho3.put(TipoAtributo.TIPO, TipoElemento.TRECHO);
		mapaTrecho3.put(TipoAtributo.DISTANCIA, 25.5f);
		mapaTrecho3.put(TipoAtributo.ID_TR_CH_A, "chave3");
		mapaTrecho3.put(TipoAtributo.ID_TR_CH_B, "chave2");
		mapaTrecho3.put(TipoAtributo.N_COMPOSICOES, 0);
		
		HashMap<TipoAtributo, Object> mapaTrecho4 = new HashMap<TipoAtributo, Object>();
		mapaTrecho4.put(TipoAtributo.ID, "trecho4");
		mapaTrecho4.put(TipoAtributo.TIPO, TipoElemento.TRECHO);
		mapaTrecho4.put(TipoAtributo.DISTANCIA, 44.1f);
		mapaTrecho4.put(TipoAtributo.ID_TR_CH_A, "chave2");
		mapaTrecho4.put(TipoAtributo.ID_TR_CH_B, "chave4");
		mapaTrecho4.put(TipoAtributo.N_COMPOSICOES, 0);
		
		HashMap<TipoAtributo, Object> mapaTrecho5 = new HashMap<TipoAtributo, Object>();
		mapaTrecho5.put(TipoAtributo.ID, "trecho5");
		mapaTrecho5.put(TipoAtributo.TIPO, TipoElemento.TRECHO);
		mapaTrecho5.put(TipoAtributo.DISTANCIA, 109.7f);
		mapaTrecho5.put(TipoAtributo.ID_TR_CH_A, "chave3");
		mapaTrecho5.put(TipoAtributo.ID_TR_CH_B, "chave4");
		mapaTrecho5.put(TipoAtributo.N_COMPOSICOES, 1);

		malha.getTrechos().get("trecho5").adicionarComposicao(malha.getComposicoes().get("composicao7"), true);
		
		HashMap<TipoAtributo, Object> mapaTrecho6 = new HashMap<TipoAtributo, Object>();
		mapaTrecho6.put(TipoAtributo.ID, "trecho6");
		mapaTrecho6.put(TipoAtributo.TIPO, TipoElemento.TRECHO);
		mapaTrecho6.put(TipoAtributo.DISTANCIA, 62.3f);
		mapaTrecho6.put(TipoAtributo.ID_TR_CH_A, "chave4");
		mapaTrecho6.put(TipoAtributo.ID_TR_CH_B, "chave1");
		mapaTrecho6.put(TipoAtributo.N_COMPOSICOES, 0);
		
		
		/***** COMPOSICOES *****/
		
		HashMap<TipoAtributo, Object> mapaComposicao1 = new HashMap<TipoAtributo, Object>();
		mapaComposicao1.put(TipoAtributo.ID, "composicao1");
		mapaComposicao1.put(TipoAtributo.TIPO, TipoElemento.COMPOSICAO);
		mapaComposicao1.put(TipoAtributo.COMPRIMENTO, 5);
		mapaComposicao1.put(TipoAtributo.VELOCIDADE_MAX, 1.2f);
		mapaComposicao1.put(TipoAtributo.ACELERACAO_MAX, 0.5f);
		mapaComposicao1.put(TipoAtributo.FRENAGEM_MAX, 0.4f);
		mapaComposicao1.put(TipoAtributo.ITINERARIO, new String[] {"trecho1", "trecho4"});
		mapaComposicao1.put(TipoAtributo.PARTIDA, 10);
		mapaComposicao1.put(TipoAtributo.ID_TR_CH_ATUAL, "chave1");
		mapaComposicao1.put(TipoAtributo.POSICAO_ATUAL, 0f);
		mapaComposicao1.put(TipoAtributo.VEL_ATUAL, 0f);
		mapaComposicao1.put(TipoAtributo.SENTIDO_ATUAL, true);
		mapaComposicao1.put(TipoAtributo.ACEL_ATUAL, 0f);
		mapaComposicao1.put(TipoAtributo.FREN_ATUAL, 0f);
		mapaComposicao1.put(TipoAtributo.EM_MOVIMENTO, false);
				
		HashMap<TipoAtributo, Object> mapaComposicao2 = new HashMap<TipoAtributo, Object>();
		mapaComposicao2.put(TipoAtributo.ID, "composicao2");
		mapaComposicao2.put(TipoAtributo.TIPO, TipoElemento.COMPOSICAO);
		mapaComposicao2.put(TipoAtributo.COMPRIMENTO, 3);
		mapaComposicao2.put(TipoAtributo.VELOCIDADE_MAX, 1.8f);
		mapaComposicao2.put(TipoAtributo.ACELERACAO_MAX, 0.6f);
		mapaComposicao2.put(TipoAtributo.FRENAGEM_MAX, 0.5f);
		mapaComposicao2.put(TipoAtributo.ITINERARIO, new String[] {"trecho1", "trecho3"});
		mapaComposicao2.put(TipoAtributo.PARTIDA, 0);
		mapaComposicao2.put(TipoAtributo.ID_TR_CH_ATUAL, "trecho1");
		mapaComposicao2.put(TipoAtributo.POSICAO_ATUAL, 8.5f);
		mapaComposicao2.put(TipoAtributo.VEL_ATUAL, 1.2f);
		mapaComposicao2.put(TipoAtributo.SENTIDO_ATUAL, true);
		mapaComposicao2.put(TipoAtributo.ACEL_ATUAL, 0f);
		mapaComposicao2.put(TipoAtributo.FREN_ATUAL, 0f);
		mapaComposicao2.put(TipoAtributo.EM_MOVIMENTO, true);
		
		HashMap<TipoAtributo, Object> mapaComposicao3 = new HashMap<TipoAtributo, Object>();
		mapaComposicao3.put(TipoAtributo.ID, "composicao3");
		mapaComposicao3.put(TipoAtributo.TIPO, TipoElemento.COMPOSICAO);
		mapaComposicao3.put(TipoAtributo.COMPRIMENTO, 4);
		mapaComposicao3.put(TipoAtributo.VELOCIDADE_MAX, 1.6f);
		mapaComposicao3.put(TipoAtributo.ACELERACAO_MAX, 0.3f);
		mapaComposicao3.put(TipoAtributo.FRENAGEM_MAX, 0.3f);
		mapaComposicao3.put(TipoAtributo.ITINERARIO, new String[] {"trecho2", "trecho5"});
		mapaComposicao3.put(TipoAtributo.PARTIDA, 2);
		mapaComposicao3.put(TipoAtributo.ID_TR_CH_ATUAL, "chave1");
		mapaComposicao3.put(TipoAtributo.POSICAO_ATUAL, 6f);
		mapaComposicao3.put(TipoAtributo.VEL_ATUAL, 0f);
		mapaComposicao3.put(TipoAtributo.SENTIDO_ATUAL, true);
		mapaComposicao3.put(TipoAtributo.ACEL_ATUAL, 0f);
		mapaComposicao3.put(TipoAtributo.FREN_ATUAL, 0f);
		mapaComposicao3.put(TipoAtributo.EM_MOVIMENTO, false);
		
		HashMap<TipoAtributo, Object> mapaComposicao4 = new HashMap<TipoAtributo, Object>();
		mapaComposicao4.put(TipoAtributo.ID, "composicao4");
		mapaComposicao4.put(TipoAtributo.TIPO, TipoElemento.COMPOSICAO);
		mapaComposicao4.put(TipoAtributo.COMPRIMENTO, 8);
		mapaComposicao4.put(TipoAtributo.VELOCIDADE_MAX, 1.2f);
		mapaComposicao4.put(TipoAtributo.ACELERACAO_MAX, 0.3f);
		mapaComposicao4.put(TipoAtributo.FRENAGEM_MAX, 0.2f);
		mapaComposicao4.put(TipoAtributo.ITINERARIO, new String[] {"trecho4"});
		mapaComposicao4.put(TipoAtributo.PARTIDA, 0);
		mapaComposicao4.put(TipoAtributo.ID_TR_CH_ATUAL, "chave2");
		mapaComposicao4.put(TipoAtributo.POSICAO_ATUAL, 0f);
		mapaComposicao4.put(TipoAtributo.VEL_ATUAL, 0f);
		mapaComposicao4.put(TipoAtributo.SENTIDO_ATUAL, true);
		mapaComposicao4.put(TipoAtributo.ACEL_ATUAL, 0f);
		mapaComposicao4.put(TipoAtributo.FREN_ATUAL, 0f);
		mapaComposicao4.put(TipoAtributo.EM_MOVIMENTO, false);
		
		HashMap<TipoAtributo, Object> mapaComposicao5 = new HashMap<TipoAtributo, Object>();
		mapaComposicao5.put(TipoAtributo.ID, "composicao5");
		mapaComposicao5.put(TipoAtributo.TIPO, TipoElemento.COMPOSICAO);
		mapaComposicao5.put(TipoAtributo.COMPRIMENTO, 11);
		mapaComposicao5.put(TipoAtributo.VELOCIDADE_MAX, 1.0f);
		mapaComposicao5.put(TipoAtributo.ACELERACAO_MAX, 0.2f);
		mapaComposicao5.put(TipoAtributo.FRENAGEM_MAX, 0.1f);
		mapaComposicao5.put(TipoAtributo.ITINERARIO, new String[] {"trecho5"});
		mapaComposicao5.put(TipoAtributo.PARTIDA, 0);
		mapaComposicao5.put(TipoAtributo.ID_TR_CH_ATUAL, "chave4");
		mapaComposicao5.put(TipoAtributo.POSICAO_ATUAL, 0f);
		mapaComposicao5.put(TipoAtributo.VEL_ATUAL, 0f);
		mapaComposicao5.put(TipoAtributo.SENTIDO_ATUAL, false);
		mapaComposicao5.put(TipoAtributo.ACEL_ATUAL, 0f);
		mapaComposicao5.put(TipoAtributo.FREN_ATUAL, 0f);
		mapaComposicao5.put(TipoAtributo.EM_MOVIMENTO, false);
		

		HashMap<TipoAtributo, Object> mapaComposicao6 = new HashMap<TipoAtributo, Object>();
		mapaComposicao6.put(TipoAtributo.ID, "composicao6");
		mapaComposicao6.put(TipoAtributo.TIPO, TipoElemento.COMPOSICAO);
		mapaComposicao6.put(TipoAtributo.COMPRIMENTO, 11);
		mapaComposicao6.put(TipoAtributo.VELOCIDADE_MAX, 1.0f);
		mapaComposicao6.put(TipoAtributo.ACELERACAO_MAX, 0.2f);
		mapaComposicao6.put(TipoAtributo.FRENAGEM_MAX, 0.1f);
		mapaComposicao6.put(TipoAtributo.ITINERARIO, new String[] {"trecho2"});
		mapaComposicao6.put(TipoAtributo.PARTIDA, 0);
		mapaComposicao6.put(TipoAtributo.ID_TR_CH_ATUAL, "trecho2");
		mapaComposicao6.put(TipoAtributo.POSICAO_ATUAL, 0f);
		mapaComposicao6.put(TipoAtributo.VEL_ATUAL, -0.6f);
		mapaComposicao6.put(TipoAtributo.SENTIDO_ATUAL, false);
		mapaComposicao6.put(TipoAtributo.ACEL_ATUAL, 0f);
		mapaComposicao6.put(TipoAtributo.FREN_ATUAL, 0f);
		mapaComposicao6.put(TipoAtributo.EM_MOVIMENTO, true);
		
		
		HashMap<TipoAtributo, Object> mapaComposicao7 = new HashMap<TipoAtributo, Object>();
		mapaComposicao7.put(TipoAtributo.ID, "composicao7");
		mapaComposicao7.put(TipoAtributo.TIPO, TipoElemento.COMPOSICAO);
		mapaComposicao7.put(TipoAtributo.COMPRIMENTO, 11);
		mapaComposicao7.put(TipoAtributo.VELOCIDADE_MAX, 1.0f);
		mapaComposicao7.put(TipoAtributo.ACELERACAO_MAX, 0.2f);
		mapaComposicao7.put(TipoAtributo.FRENAGEM_MAX, 0.1f);
		mapaComposicao7.put(TipoAtributo.ITINERARIO, new String[] {"trecho5"});
		mapaComposicao7.put(TipoAtributo.PARTIDA, 0);
		mapaComposicao7.put(TipoAtributo.ID_TR_CH_ATUAL, "trecho5");
		mapaComposicao7.put(TipoAtributo.POSICAO_ATUAL, 0f);
		mapaComposicao7.put(TipoAtributo.VEL_ATUAL, 0.6f);
		mapaComposicao7.put(TipoAtributo.SENTIDO_ATUAL, true);
		mapaComposicao7.put(TipoAtributo.ACEL_ATUAL, 0f);
		mapaComposicao7.put(TipoAtributo.FREN_ATUAL, 0f);
		mapaComposicao7.put(TipoAtributo.EM_MOVIMENTO, true);
		
		
		teste.testeAtualizarElemento(malha, "chave1", mapaChave1);
		teste.testeAtualizarElemento(malha, "chave2", mapaChave2);
		teste.testeAtualizarElemento(malha, "chave3", mapaChave3);
		teste.testeAtualizarElemento(malha, "chave4", mapaChave4);
		teste.testeAtualizarElemento(malha, "trecho1", mapaTrecho1);
		teste.testeAtualizarElemento(malha, "trecho2", mapaTrecho2);
		teste.testeAtualizarElemento(malha, "trecho3", mapaTrecho3);
		teste.testeAtualizarElemento(malha, "trecho4", mapaTrecho4);
		teste.testeAtualizarElemento(malha, "trecho5", mapaTrecho5);
		teste.testeAtualizarElemento(malha, "trecho6", mapaTrecho6);
		teste.testeAtualizarElemento(malha, "composicao1", mapaComposicao1);
		teste.testeAtualizarElemento(malha, "composicao2", mapaComposicao2);
		teste.testeAtualizarElemento(malha, "composicao3", mapaComposicao3);
		teste.testeAtualizarElemento(malha, "composicao4", mapaComposicao4);
		teste.testeAtualizarElemento(malha, "composicao5", mapaComposicao5);
		teste.testeAtualizarElemento(malha, "composicao6", mapaComposicao6);
		teste.testeAtualizarElemento(malha, "composicao7", mapaComposicao7);
		
		teste.testeMudarChave(malha);
		
		teste.testeEncontrarChaveAssociada(malha);
		
		teste.testeAtualizarMalha(malha);
		
		teste.testeAcelerarComposicao(malha);
		
		teste.testeFrearComposicao(malha);
		
		teste.testeAdicionarComposicaoACaminho(malha);
		teste.testeProximaComposicaoACaminho(malha);
		teste.testeGetTrensACaminho(malha);
		teste.testeRemoverComposicaoACaminho(malha);
		
		
		
		teste.testeRemoverComposicao(malha);
		
		System.out.println("SUUUUCEEESSO!!");
	}
	

}
